home *** CD-ROM | disk | FTP | other *** search
/ Collection of Internet / Collection of Internet.iso / msdos / lynx / source / wattcp / src / pcrecv.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-25  |  4.7 KB  |  197 lines
  1. #include <wattcp.h>
  2. #include <mem.h>
  3.  
  4. #define RECV_USED    0xf7e3d2b1L
  5. #define RECV_UNUSED  0xe6d2c1afL
  6.  
  7. typedef struct {
  8.     longword      recv_sig;
  9.     byte    *recv_bufs;
  10.     word     recv_bufnum;    /* for udp */
  11.     word     recv_len;    /* for tcp */
  12. } recv_data;
  13.  
  14. typedef struct {
  15.     longword     buf_sig;
  16.     longword     buf_hisip;
  17.     word         buf_hisport;
  18.     int         buf_len;
  19.     byte     buf_data[ 1500 ];
  20. } recv_buf;
  21.  
  22.  
  23. /*
  24.  *  recvd - gets upcalled when data arrives
  25.  */
  26. int _recvdaemon( udp_Socket *s, byte *data, int len, tcp_PseudoHeader *ph, void *h)
  27. {
  28.     recv_data *r;
  29.     recv_buf *p;
  30.     tcp_Socket *t;
  31.     int i;
  32.     udp_Header *uh;
  33.  
  34.     /* check for length problem */
  35.     if ( !len || (len >= 1500 )) return( 0 );
  36.  
  37.     switch ( s->ip_type ) {
  38.     case UDP_PROTO :r = (recv_data*)(s->rdata);
  39.                         uh = (udp_Header *) h;
  40.             if (r->recv_sig != RECV_USED ) {
  41.                 outs("ERROR: udp recv data conflict");
  42.                 return( 0 );
  43.             }
  44.  
  45.             p = (recv_buf *)(r->recv_bufs);
  46.  
  47.             /* find a buffer */
  48.             for ( i = 0; i < r->recv_bufnum ; ++i , ++p) {
  49.                 switch ( p->buf_sig ) {
  50.                 case RECV_USED   : break;
  51.                 case RECV_UNUSED :
  52.                     /* take this one */
  53.                     p->buf_sig = RECV_USED;
  54.                     p->buf_len = len;
  55.                     p->buf_hisip = ph->src;
  56.                                         p->buf_hisport = uh->srcPort;
  57.                     movmem( data, p->buf_data, len );
  58.                     return( 0 );
  59.                 default       :
  60.                     outs("ERROR: sock_recv_init data err");
  61.                     return( 0 );
  62.                 }
  63.             }
  64.             return( 0 );
  65.     case TCP_PROTO :
  66.             t= (tcp_Socket*)s;
  67.             r = (recv_data*)(t->rdata);
  68.             if (r->recv_sig != RECV_USED ) {
  69.                 outs("ERROR: udp recv data conflict");
  70.                 return( 0 );
  71.             }
  72.  
  73.             /* stick it on the end if you can */
  74.             i = t->maxrdatalen - t->rdatalen;
  75.             if ( i > 1 ) {
  76.                 /* we can accept some of this */
  77.                 if ( len > i ) len = i;
  78.                 movmem( data, &r->recv_bufs[s->rdatalen], len );
  79.                 s->rdatalen += len;
  80.                 return( len );
  81.             }
  82.             return( 0 );    /* didn't take none */
  83.     }
  84. }
  85.  
  86.  
  87.  
  88. sock_recv_init( udp_Socket *s, void *space, word len )
  89. {
  90.     tcp_Socket *t;
  91.     recv_buf *p;
  92.     recv_data *r;
  93.     int i;
  94.  
  95.     /* clear data area */
  96.     memset( p = space, 0, len );
  97.  
  98.     s->dataHandler = _recvdaemon;
  99.     /* clear table */
  100.     memset( r = (recv_data*) s->rddata, 0, tcp_MaxBufSize );
  101.  
  102.     r->recv_sig = RECV_USED;
  103.     r->recv_bufs = (byte *) p;
  104.     r->recv_bufnum = len / sizeof( recv_buf );
  105.     r->recv_len = len;
  106.     if (s->ip_type == UDP_PROTO )
  107.     for ( i = 0 ; i < r->recv_bufnum ; ++i, ++p )
  108.         p->buf_sig = RECV_UNUSED;
  109.     return( 0 );
  110. }
  111.  
  112. int sock_recv_from( udp_Socket *s, long *hisip, word *hisport, char *buffer, int len, word flags )
  113. {
  114.     tcp_Socket *t;
  115.     recv_data *r;
  116.     recv_buf *p;
  117.     int i;
  118.  
  119.     r = (recv_data *) s->rdata;
  120.     if (r->recv_sig != RECV_USED )
  121.     return( -1 );
  122.  
  123.     switch ( s->ip_type ) {
  124.     case UDP_PROTO :
  125.         p = (recv_buf *) r->recv_bufs;
  126.  
  127.         /* find a buffer */
  128.         for ( i = 0; i < r->recv_bufnum ; ++i , ++p) {
  129.         switch ( p->buf_sig ) {
  130.             case RECV_UNUSED:
  131.             break;
  132.             case RECV_USED  :
  133.             p->buf_sig = RECV_USED;
  134.             if ( len > p->buf_len ) len = p->buf_len;
  135.             movmem( p->buf_data, buffer, len );
  136.                         if (hisip) *hisip = p->buf_hisip;
  137.                         if (hisport) *hisport = p->buf_hisport;
  138.             p->buf_sig = RECV_UNUSED;
  139.             return( len );
  140.             default      :
  141.             outs("ERROR: sock_recv_init data err");
  142.             return( 0 );
  143.         }
  144.         }
  145.         return( 0 );
  146.     case TCP_PROTO :
  147.         t = (tcp_Socket *) s;
  148.         if ( len > t->rdatalen ) len = t->rdatalen;
  149.         if ( len )
  150.         movmem( r->recv_bufs, buffer, len );
  151.         return( len );
  152.     }
  153.     return( 0 );
  154. }
  155. int sock_recv( udp_Socket *s, char *buffer, int len, word flags )
  156. {
  157.     tcp_Socket *t;
  158.     recv_data *r;
  159.     recv_buf *p;
  160.     int i;
  161.  
  162.     r = (recv_data *) s->rdata;
  163.     if (r->recv_sig != RECV_USED )
  164.     return( -1 );
  165.  
  166.     switch ( s->ip_type ) {
  167.     case UDP_PROTO :
  168.         p = (recv_buf *) r->recv_bufs;
  169.  
  170.         /* find a buffer */
  171.         for ( i = 0; i < r->recv_bufnum ; ++i , ++p) {
  172.         switch ( p->buf_sig ) {
  173.             case RECV_UNUSED:
  174.             break;
  175.             case RECV_USED  :
  176.             p->buf_sig = RECV_USED;
  177.             if ( len > p->buf_len ) len = p->buf_len;
  178.             movmem( p->buf_data, buffer, len );
  179.             p->buf_sig = RECV_UNUSED;
  180.             return( len );
  181.             default      :
  182.             outs("ERROR: sock_recv_init data err");
  183.             return( 0 );
  184.         }
  185.         }
  186.         return( 0 );
  187.     case TCP_PROTO :
  188.         t = (tcp_Socket*) s;
  189.         if ( len > t->rdatalen ) len = t->rdatalen;
  190.         if ( len )
  191.         movmem( r->recv_bufs, buffer, len );
  192.         return( len );
  193.     }
  194.     return( 0 );
  195. }
  196.  
  197.